package com.uls.questionnaire.service.impl;

import java.util.*;

import com.uls.common.core.domain.AjaxResult;
import com.uls.common.core.domain.entity.SysUser;
import com.uls.common.utils.DateUtils;
import com.uls.questionnaire.domain.ZxhOptiones;
import com.uls.questionnaire.mapper.ZxhQuestionMapper;
import com.uls.questionnaire.service.IZxhOptionesService;
import com.uls.questionnaire.service.IZxhQuestionService;
import com.uls.questionnaire.vo.QuestionnaireVO;
import com.uls.questionnaire.vo.QuestionnaireViewVO;
import com.uls.questionnaire.vo.TaskCommentVo;
import com.uls.system.service.ISysUserService;
import org.activiti.engine.HistoryService;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.identity.Authentication;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Comment;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.uls.common.utils.StringUtils;
import org.springframework.transaction.annotation.Transactional;
import com.uls.questionnaire.domain.ZxhQuestion;
import com.uls.questionnaire.mapper.ZxhQuestionnaireMapper;
import com.uls.questionnaire.domain.ZxhQuestionnaire;
import com.uls.questionnaire.service.IZxhQuestionnaireService;

/**
 * 问卷信息Service业务层处理
 * 
 * @author zxh
 * @date 2024-10-31
 */
@Service
public class ZxhQuestionnaireServiceImpl implements IZxhQuestionnaireService 
{
    @Autowired
    private ZxhQuestionnaireMapper zxhQuestionnaireMapper;
    @Autowired
    private ZxhQuestionMapper zxhQuestionMapper;

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;
    @Autowired
    private ISysUserService userService;  //去用户名


    @Autowired
    private HistoryService historyService;


    private AjaxResult log;

    @Autowired
    private IZxhQuestionService zxhQuestionService; // 需要注入问题服务
    @Autowired
    private IZxhOptionesService zxhOptionesService;
    /**
     * 查询问卷信息
     * 
     * @param questionnaireId 问卷信息主键
     * @return 问卷信息
     */
    @Override
    public ZxhQuestionnaire selectZxhQuestionnaireByQuestionnaireId(Long questionnaireId)
    {
        return zxhQuestionnaireMapper.selectZxhQuestionnaireByQuestionnaireId(questionnaireId);
    }

    /**
     * 查询问卷信息列表
     * 
     * @param zxhQuestionnaire 问卷信息
     * @return 问卷信息
     */
    @Override
    public List<ZxhQuestionnaire> selectZxhQuestionnaireList(ZxhQuestionnaire zxhQuestionnaire)
    {
        return zxhQuestionnaireMapper.selectZxhQuestionnaireList(zxhQuestionnaire);
    }

    /**
     * 新增问卷信息
     * 
     * @param zxhQuestionnaire 问卷信息
     * @return 结果
     */
    @Transactional
    @Override
    public int insertZxhQuestionnaire(ZxhQuestionnaire zxhQuestionnaire)
    {
        zxhQuestionnaire.setCreateTime(DateUtils.getNowDate());
        int rows = zxhQuestionnaireMapper.insertZxhQuestionnaire(zxhQuestionnaire);
        insertZxhQuestion(zxhQuestionnaire);
        return rows;
    }

    /**
     * 修改问卷信息
     * 
     * @param zxhQuestionnaire 问卷信息
     * @return 结果
     */
    @Transactional
    @Override
    public int updateZxhQuestionnaire(ZxhQuestionnaire zxhQuestionnaire)
    {
        zxhQuestionnaireMapper.deleteZxhQuestionByQuestionnaireId(zxhQuestionnaire.getQuestionnaireId());
        insertZxhQuestion(zxhQuestionnaire);
        return zxhQuestionnaireMapper.updateZxhQuestionnaire(zxhQuestionnaire);
    }

    /**
     * 批量删除问卷信息
     * 
     * @param questionnaireIds 需要删除的问卷信息主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteZxhQuestionnaireByQuestionnaireIds(Long[] questionnaireIds)
    {
        zxhQuestionnaireMapper.deleteZxhQuestionByQuestionnaireIds(questionnaireIds);
        return zxhQuestionnaireMapper.deleteZxhQuestionnaireByQuestionnaireIds(questionnaireIds);
    }

    /**
     * 删除问卷信息信息
     * 
     * @param questionnaireId 问卷信息主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteZxhQuestionnaireByQuestionnaireId(Long questionnaireId)
    {
        zxhQuestionnaireMapper.deleteZxhQuestionByQuestionnaireId(questionnaireId);
        return zxhQuestionnaireMapper.deleteZxhQuestionnaireByQuestionnaireId(questionnaireId);
    }



    /**
     * 新增问题信息信息
     * 
     * @param zxhQuestionnaire 问卷信息对象
     */
    public void insertZxhQuestion(ZxhQuestionnaire zxhQuestionnaire)
    {
        List<ZxhQuestion> zxhQuestionList = zxhQuestionnaire.getZxhQuestionList();
        Long questionnaireId = zxhQuestionnaire.getQuestionnaireId();
        if (StringUtils.isNotNull(zxhQuestionList))
        {
            List<ZxhQuestion> list = new ArrayList<ZxhQuestion>();
            for (ZxhQuestion zxhQuestion : zxhQuestionList)
            {
                zxhQuestion.setQuestionnaireId(questionnaireId);
                list.add(zxhQuestion);
            }
            if (list.size() > 0)
            {
                zxhQuestionnaireMapper.batchZxhQuestion(list);
            }
        }
    }

    @Override
    public List<QuestionnaireViewVO> getQuestionnaireDetails(Long questionnaireId) {
        return zxhQuestionnaireMapper.selectQuestionnaireDetails(questionnaireId);
    }

    @Override
    public List<QuestionnaireVO> getAllQuestionnaires() {
        return zxhQuestionnaireMapper.getAllQuestionnaires();
    }

    @Override
    @Transactional
    public int submit(Long questionnaireId, Long userId) {
        ZxhQuestionnaire questionnaire=zxhQuestionnaireMapper.selectZxhQuestionnaireByQuestionnaireId(questionnaireId);

        String processDefiKey ="mySurvey0";
        Map<String, Object> variables = new HashMap<String,Object>();
        variables.put("inputUser1",userId);
        variables.put("inputUser2",127);  //先写死，是主任的编号

        if (questionnaire.getStatus()==0) {
            ProcessInstance pi = runtimeService.startProcessInstanceByKey(processDefiKey, variables);
            questionnaire.setFlowInstantId(Long.parseLong(pi.getProcessInstanceId()));  // 把流程实例id与业务系统绑定
            questionnaire.setStatus(2);//状态(0-未提交，1-打回，2-审核中，3-已完成）
            TaskQuery taskQuery = taskService.createTaskQuery();
            // 办理人的任务列表
            List<Task> list = taskQuery
                    .taskAssignee(""+userId)
                    .processInstanceId(pi.getProcessInstanceId())
                    .list();
            Task task=list.get(0);
            taskService.complete(task.getId());

            return zxhQuestionnaireMapper.updateZxhQuestionnaire(questionnaire) ;
        }
        //流程启动了，打回重新审批，就不用再启动流程
        else{

            Long flowInstantId=questionnaire.getFlowInstantId();
            TaskQuery taskQuery = taskService.createTaskQuery();
            // 办理人的任务列表
            List<Task> list = taskQuery
                    .processInstanceId("" + flowInstantId)
                    .list();
            Task task=list.get(0);
            taskService.complete(task.getId());
            questionnaire.setStatus(2);//状态(0-未提交，1-打回，2-审核中，3-已完成）
            return zxhQuestionnaireMapper.updateZxhQuestionnaire(questionnaire);
        }
    }

    @Override
    public List<ZxhQuestionnaire> noFinishTask(Long userId, String processDefiniionKey) {
        List<ZxhQuestionnaire> listquestionnaire=new ArrayList<ZxhQuestionnaire>();
        // 创建一个任务查询对象
        TaskQuery taskQuery = taskService.createTaskQuery();
        // 办理人的任务列表
        List<Task> list = taskQuery
                .taskAssignee(""+userId)
                .processDefinitionKey(processDefiniionKey)
                .list();
        // 遍历任务列表
        if (list != null && list.size() > 0) {
            for (Task task : list) {
                if (!task.getName().equals("问卷发布申请")) {
                    Long flowInstanceId = Long.parseLong(task.getProcessInstanceId());
                    //根据流程id查询学生mapper的方法
                    ZxhQuestionnaire questionnaire = zxhQuestionnaireMapper.selectZxhQuestionnaireFlowId(flowInstanceId);
                    listquestionnaire.add(questionnaire);
                }

            }
        }
        return listquestionnaire;
    }

    @Override
    public List<ZxhQuestionnaire> noFinishTask(Long userId, String processDefiniionKey, ZxhQuestionnaire questionnaire) {
        List<ZxhQuestionnaire> listquestionnaire=new ArrayList<ZxhQuestionnaire>();
        // 创建一个任务查询对象
        TaskQuery taskQuery = taskService.createTaskQuery();
        // 办理人的任务列表
        List<Task> list = taskQuery
                .taskAssignee(""+userId)
                .processDefinitionKey(processDefiniionKey)
                .list();
        // 遍历任务列表
        if (list != null && list.size() > 0) {
            for (Task task : list) {
                if (!task.getName().equals("问卷发布申请")) {
                    Long flowInstanceId = Long.parseLong(task.getProcessInstanceId());
                    questionnaire.setFlowInstantId(flowInstanceId);
                    //根据流程id和其他条件查询老师mapper的方法
                    ZxhQuestionnaire  questionnaire1 = zxhQuestionnaireMapper.selectZxhQuestionnaireFlowIdOther(questionnaire);
                    if ( questionnaire1!=null)
                        listquestionnaire.add(questionnaire1);
                }

            }
        }

        return  listquestionnaire;
    }

    @Override
    public void completeTask(Long flowInstantId, Integer agree, Long userId, String comment, Long questionnaireId)
    {
        ZxhQuestionnaire questionnaire=zxhQuestionnaireMapper.selectZxhQuestionnaireByQuestionnaireId(questionnaireId);

        TaskQuery taskQuery = taskService.createTaskQuery();
        // 办理人的任务列表
        List<Task> list = taskQuery
                .processInstanceId("" + flowInstantId)
                .list();
        // 遍历任务列表
        Map<String, Object> params = new HashMap<String, Object>();

        if (list != null && list.size() > 0)
        {
            for (Task task : list)
            {

                if (task.getName().equals("主任审批"))
                {
                    if (agree==1)
                    {

                        params.put("inputUser3", 135);  //固定一个人员4
                        questionnaire.setStatus(2);//状态(0-未提交，1-打回，2-审核中，3-已完成）
                    }
                    else
                    {
                       questionnaire.setStatus(1);
                    }
                    params.put("pass1", agree);  //给流程变量赋值

                }
                else if (task.getName().equals("书记审批"))
                {
                    if (agree == 1)
                    {
                        params.put("inputUser4", 136);  // 固定一个人员3，假设是书记的审批人
                        questionnaire.setStatus(2);  // 状态：审核中
                    }
                    else
                    {
                        questionnaire.setStatus(1);  // 状态：打回
                    }
                    params.put("pass2", agree);  // 给流程变量赋值
                }
                else if (task.getName().equals("院长审批"))
                {
                    if (agree==1)
                    {
                        questionnaire.setStatus(3);
                        questionnaire.setPublishStatus(1l);
                    }
                    else
                    {
                       questionnaire.setStatus(1);
                    }
                    params.put("pass3", agree);  //给流程变量赋值
                }

                zxhQuestionnaireMapper.updateZxhQuestionnaire(questionnaire);

                // 添加批注时候的审核人，通常应该从session获取,现在从redis
                Authentication.setAuthenticatedUserId(userId.toString());
                // 添加批注
                taskService.addComment(task.getId(), task.getProcessInstanceId(), comment);
                // taskId：任务id
                taskService.complete(task.getId(), params);

            }
        }
    }

    @Override
    public List<TaskCommentVo> getTaskCommentList(Long flowInstantId) {
        List<TaskCommentVo> taskCommentVoList=new ArrayList<>();

        List<Comment> list = new ArrayList();

        //从历史批注中取数据
        list = taskService.getProcessInstanceComments(""+flowInstantId);

        for (Comment com : list) {
            TaskCommentVo taskCommentVo=new TaskCommentVo();
            taskCommentVo.setMessage(com.getFullMessage());

           SysUser user=userService.selectUserById(Long.parseLong(com.getUserId()));  //查询用户名

            taskCommentVo.setUserName(user.getUserName());


            //从历史任务取数据
            List<HistoricTaskInstance> hist= historyService.createHistoricTaskInstanceQuery()
                    .processInstanceId(""+flowInstantId)
                    .taskId(com.getTaskId())
                    .list();
            if(hist!=null&&hist.size()>0){
                HistoricTaskInstance historicTaskInstance=hist.get(0);
                taskCommentVo.setTaskKeyId(historicTaskInstance.getTaskDefinitionKey());
                taskCommentVo.setTaskName(historicTaskInstance.getName());
            }

            taskCommentVoList.add(taskCommentVo);

        }

        //排序
        List<TaskCommentVo> taskCommentVoListSort=new ArrayList<>();

        for(int i= taskCommentVoList.size()-1;i>=0;i--)
        {
            TaskCommentVo temp=taskCommentVoList.get(i);
            taskCommentVoListSort.add(temp);
        }

        return taskCommentVoListSort;
    }

    @Override
    public List<ZxhQuestionnaire> finishTask(Long userId, String processDefiniionKey) {
        List<ZxhQuestionnaire> listFinish=new ArrayList<ZxhQuestionnaire>();
        List<HistoricTaskInstance> list=historyService
                .createHistoricTaskInstanceQuery()
                .taskAssignee(userId.toString())
                .processDefinitionKey(processDefiniionKey)
                .processFinished()
                .list();
        if(list!=null&&list.size()>0)
        {
            for(HistoricTaskInstance temp:list)
            {
                if(!temp.getName().equals("问卷发布申请"))
                {
                    Long flowInstanceId=Long.parseLong(temp.getProcessInstanceId());
                    ZxhQuestionnaire questionnaire=zxhQuestionnaireMapper.selectZxhQuestionnaireFlowId(flowInstanceId);
                    listFinish.add(questionnaire);

                }
            }
        }
        List<ZxhQuestionnaire> listFinish1=new ArrayList<>(new HashSet<>(listFinish));
        return listFinish1;
    }

    @Override
    public List<ZxhQuestionnaire> finishTask(Long userId, String processDefiniionKey, ZxhQuestionnaire questionnaireQuery) {
        List<ZxhQuestionnaire> listFinishStudent=new ArrayList<ZxhQuestionnaire>();
        List<HistoricTaskInstance> list=historyService
                .createHistoricTaskInstanceQuery()
                .taskAssignee(userId.toString())
                .processDefinitionKey(processDefiniionKey)
                .processFinished()
                .list();
        if(list!=null&&list.size()>0)
        {
            for(HistoricTaskInstance temp:list)
            {
                if(!temp.getName().equals("问卷发布申请"))
                {
                    Long flowInstanceId=Long.parseLong(temp.getProcessInstanceId());
                    questionnaireQuery.setFlowInstantId(flowInstanceId);
                    ZxhQuestionnaire questionnaire=zxhQuestionnaireMapper.selectZxhQuestionnaireFlowIdOther(questionnaireQuery);
                    if(questionnaire!=null)
                    {
                        listFinishStudent.add(questionnaire);
                    }

                }
            }
        }
        List<ZxhQuestionnaire> listFinishStudent1=new ArrayList<>(new HashSet<>(listFinishStudent));
        return listFinishStudent1;
    }


}
